/*******************************************************************************
 * Copyright (c) 2004, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.draw2d.graph;

import org.eclipse.draw2d.geometry.Insets;

/**
 * Encapsulates the conversion of a long edge to multiple short edges and back.
 * @since 3.1
 */
class VirtualNodeCreation extends RevertableChange {

private final Edge edge;
private final DirectedGraph graph;
private Node nodes[];
private Edge[] edges;

private static final int INNER_EDGE_X = 2;
private static final int LONG_EDGE_X = 8;

/**
 * Breaks a single edge into multiple edges containing virtual nodes.
 * @since 3.1
 * @param edge The edge to convert
 * @param graph the graph containing the edge
 */
public VirtualNodeCreation(Edge edge, DirectedGraph graph) {
	this.edge = edge;
	this.graph = graph;

	int size = edge.target.rank - edge.source.rank - 1;
	int offset = edge.source.rank + 1;

	Node prevNode = edge.source;
	Node currentNode;
	Edge currentEdge;
	nodes = new Node[size];
	edges = new Edge[size + 1];
	
	Insets padding = new Insets(0, edge.padding, 0, edge.padding);
	
	Subgraph s = GraphUtilities.getCommonAncestor(edge.source, edge.target);
	
	for (int i = 0; i < size; i++) {
		nodes[i] = currentNode = new VirtualNode("Virtual" + i + ':' + edge, s); //$NON-NLS-1$
		currentNode.width = edge.width;
		if (s != null) {
			currentNode.nestingIndex = s.nestingIndex;
		}

		currentNode.height = 0;
		currentNode.setPadding(padding);
		currentNode.rank = offset + i;
		graph.ranks.getRank(offset + i).add(currentNode);
		
		currentEdge = new Edge(prevNode, currentNode, 1, edge.weight * LONG_EDGE_X);
		if (i == 0) {
			currentEdge.weight = edge.weight * INNER_EDGE_X;
			currentEdge.offsetSource = edge.offsetSource;
		}
		graph.edges.add(edges[i] = currentEdge);
		graph.nodes.add(currentNode);
		prevNode = currentNode;
	}
	
	currentEdge = new Edge(prevNode, edge.target, 1, edge.weight * INNER_EDGE_X);
	currentEdge.offsetTarget = edge.offsetTarget;
	graph.edges.add(edges[edges.length - 1] = currentEdge);
	graph.removeEdge(edge);
}

void revert() {
	edge.start = edges[0].start;
	edge.end = edges[edges.length - 1].end;
	edge.vNodes = new NodeList();
	for (int i = 0; i < edges.length; i++) {
		graph.removeEdge(edges[i]);
	}
	for (int i = 0; i < nodes.length; i++) {
		edge.vNodes.add(nodes[i]);
		graph.removeNode(nodes[i]);
	}
	edge.source.outgoing.add(edge);
	edge.target.incoming.add(edge);
	
	graph.edges.add(edge);
}

}
